# ============================================================================
# distcc 分布式编译配置模块
# ============================================================================
# 提供 distcc 主机验证、JOBS 计算和动态均衡配置
# ============================================================================

if(UNIX AND NOT WIN32)
    # 检查 distcc 是否安装
    find_program(DISTCC_PROGRAM distcc)
    
    if(DISTCC_PROGRAM)
        # 检查 distcc 配置文件
        set(DISTCC_CONFIG_FILE "")
        if(EXISTS "${CMAKE_SOURCE_DIR}/.distcc.conf")
            set(DISTCC_CONFIG_FILE "${CMAKE_SOURCE_DIR}/.distcc.conf")
        elseif(EXISTS "${CMAKE_SOURCE_DIR}/ci/distcc.conf")
            set(DISTCC_CONFIG_FILE "${CMAKE_SOURCE_DIR}/ci/distcc.conf")
        endif()
        
        # 如果没有配置文件，检查环境变量
        if(NOT DISTCC_CONFIG_FILE)
            if(DEFINED ENV{DISTCC_HOSTS})
                set(DISTCC_HOSTS_VALUE "$ENV{DISTCC_HOSTS}")
                if(DISTCC_HOSTS_VALUE)
                    message(STATUS "[DistccConfig] ⚠️  未找到配置文件，但检测到环境变量 DISTCC_HOSTS，将使用环境变量设置")
                    # 使用环境变量中的 DISTCC_HOSTS，继续执行 distcc 配置
                    set(DISTCC_HOSTS "${DISTCC_HOSTS_VALUE}")
                    set(DISTCC_ENABLED_FROM_CONFIG TRUE)
                else()
                    message(STATUS "[DistccConfig] ℹ️  未找到配置文件且环境变量 DISTCC_HOSTS 为空，跳过 distcc 配置")
                    return()
                endif()
            else()
                message(STATUS "[DistccConfig] ℹ️  未找到配置文件且未检测到环境变量 DISTCC_HOSTS，跳过 distcc 配置")
                return()
            endif()
        endif()
        
        if(DISTCC_CONFIG_FILE)
            # 读取配置文件
            file(READ "${DISTCC_CONFIG_FILE}" DISTCC_CONFIG_CONTENT)
            
            # 调试信息：显示配置文件路径
            message(STATUS "[DistccConfig] 读取配置文件: ${DISTCC_CONFIG_FILE}")
            
            # 检查是否启用 distcc
            # 优先级：配置文件中的 DISTCC_ENABLED > 环境变量 DISTCC_HOSTS
            # 如果配置文件中 DISTCC_ENABLED=no，即使环境变量设置了 DISTCC_HOSTS，也不使用 distcc
            set(DISTCC_ENABLED_FROM_CONFIG FALSE)
            
            # 改进的匹配逻辑：只匹配非注释行的 DISTCC_ENABLED
            # 逐行检查配置文件，跳过注释行（以 # 开头），找到最后一个非注释的 DISTCC_ENABLED 设置
            set(DISTCC_ENABLED_VALUE "")
            
            # 将内容按行分割
            string(REPLACE "\n" ";" CONFIG_LINES "${DISTCC_CONFIG_CONTENT}")
            
            # 从前往后查找（后面的配置覆盖前面的，所以遍历到最后）
            foreach(LINE ${CONFIG_LINES})
                # 去除行首和行尾空格
                string(STRIP "${LINE}" STRIPPED_LINE)
                # 跳过空行
                if(STRIPPED_LINE)
                    # 检查是否是注释行（以 # 开头，允许前面有空格）
                    string(REGEX MATCH "^[ \t]*#" IS_COMMENT "${STRIPPED_LINE}")
                    if(NOT IS_COMMENT)
                        # 非注释行，检查是否包含 DISTCC_ENABLED
                        if(STRIPPED_LINE MATCHES "DISTCC_ENABLED[ \t]*=")
                            # 提取值：匹配 DISTCC_ENABLED= 后面的值（去除空格和可能的注释）
                            string(REGEX REPLACE "^[^=]*DISTCC_ENABLED[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_ENABLED_VALUE "${STRIPPED_LINE}")
                            # 继续查找，后面的配置会覆盖前面的
                        endif()
                    endif()
                endif()
            endforeach()
            
            # 调试信息：显示找到的值
            if(DISTCC_ENABLED_VALUE)
                message(STATUS "[DistccConfig] 检测到 DISTCC_ENABLED=${DISTCC_ENABLED_VALUE}（非注释行）")
            else()
                message(STATUS "[DistccConfig] 未找到 DISTCC_ENABLED 设置（非注释行）")
            endif()
            
            # 根据找到的值设置状态
            if(DISTCC_ENABLED_VALUE STREQUAL "no")
                # 配置文件中明确禁用 distcc
                set(DISTCC_ENABLED_FROM_CONFIG FALSE)
                # 如果环境变量中设置了 DISTCC_HOSTS，清除它
                if(DEFINED ENV{DISTCC_HOSTS})
                    unset(ENV{DISTCC_HOSTS})
                    message(STATUS "[DistccConfig] ⚠️  配置文件中 DISTCC_ENABLED=no，已清除环境变量 DISTCC_HOSTS")
                endif()
                # 直接返回，不进行任何 distcc 配置
                message(STATUS "========================================")
                message(STATUS "❌ distcc 已禁用（DISTCC_ENABLED=no）")
                message(STATUS "   配置文件: ${DISTCC_CONFIG_FILE}")
                message(STATUS "========================================")
                return()
            elseif(DISTCC_ENABLED_VALUE STREQUAL "yes")
                # 配置文件中明确启用 distcc
                set(DISTCC_ENABLED_FROM_CONFIG TRUE)
                message(STATUS "[DistccConfig] ✅ 配置文件中 DISTCC_ENABLED=yes")
            else()
                # 配置文件中没有 DISTCC_ENABLED 设置（或值不是 yes/no）
                message(STATUS "[DistccConfig] ⚠️  配置文件中未找到有效的 DISTCC_ENABLED 设置")
                # 如果环境变量中有 DISTCC_HOSTS，仍然可以使用（向后兼容）
                if(DEFINED ENV{DISTCC_HOSTS})
                    set(DISTCC_HOSTS_VALUE "$ENV{DISTCC_HOSTS}")
                    if(DISTCC_HOSTS_VALUE)
                        message(STATUS "[DistccConfig] ℹ️  检测到环境变量 DISTCC_HOSTS，将使用环境变量设置")
                        set(DISTCC_ENABLED_FROM_CONFIG TRUE)
                    else()
                        message(STATUS "[DistccConfig] ℹ️  未检测到 DISTCC_ENABLED 设置且环境变量 DISTCC_HOSTS 为空，默认禁用 distcc")
                        set(DISTCC_ENABLED_FROM_CONFIG FALSE)
                    endif()
                else()
                    message(STATUS "[DistccConfig] ℹ️  未检测到 DISTCC_ENABLED 设置和环境变量，默认禁用 distcc")
                    set(DISTCC_ENABLED_FROM_CONFIG FALSE)
                endif()
            endif()
            
            # 如果配置文件中明确设置了 DISTCC_ENABLED=yes，或者环境变量中有 DISTCC_HOSTS，则启用 distcc
            if(DISTCC_ENABLED_FROM_CONFIG)
                message(STATUS "========================================")
                message(STATUS "✅ 分布式编译: distcc")
                message(STATUS "========================================")
                
                # 提取 DISTCC_HOSTS
                string(REGEX MATCH "DISTCC_HOSTS=\"([^\"]+)\"" _ "${DISTCC_CONFIG_CONTENT}")
                if(CMAKE_MATCH_1)
                    set(DISTCC_HOSTS "${CMAKE_MATCH_1}")
                else()
                    string(REGEX MATCH "DISTCC_HOSTS=([^ \n]+)" _ "${DISTCC_CONFIG_CONTENT}")
                    if(CMAKE_MATCH_1)
                        set(DISTCC_HOSTS "${CMAKE_MATCH_1}")
                    endif()
                endif()
                
                # 提取其他配置
                if(DISTCC_CONFIG_CONTENT MATCHES "DISTCC_DYNAMIC_BALANCE=yes")
                    set(DISTCC_DYNAMIC_BALANCE "yes")
                else()
                    set(DISTCC_DYNAMIC_BALANCE "no")
                endif()
                
                if(DISTCC_CONFIG_CONTENT MATCHES "DISTCC_CHECK_GCC_VERSION=yes")
                    set(DISTCC_CHECK_GCC_VERSION "yes")
                else()
                    set(DISTCC_CHECK_GCC_VERSION "no")
                endif()
                
                # 🔥 关键：从配置文件中提取 distcc 环境变量设置
                # 使用与 DISTCC_ENABLED 相同的逐行解析逻辑，确保只读取非注释行的值
                set(DISTCC_FALLBACK_VALUE "")
                set(DISTCC_SKIP_LOCAL_RETRY_VALUE "")
                set(DISTCC_IO_TIMEOUT_VALUE "")
                set(DISTCC_VERBOSE_VALUE "")
                set(DISTCC_SAVE_TEMPS_VALUE "")
                
                # 将内容按行分割
                string(REPLACE "\n" ";" CONFIG_LINES_FOR_VARS "${DISTCC_CONFIG_CONTENT}")
                
                # 从前往后查找（后面的配置覆盖前面的）
                foreach(LINE ${CONFIG_LINES_FOR_VARS})
                    string(STRIP "${LINE}" STRIPPED_LINE)
                    if(STRIPPED_LINE)
                        # 检查是否是注释行
                        string(REGEX MATCH "^[ \t]*#" IS_COMMENT "${STRIPPED_LINE}")
                        if(NOT IS_COMMENT)
                            # 提取 DISTCC_FALLBACK（支持带引号和不带引号的值）
                            if(STRIPPED_LINE MATCHES "DISTCC_FALLBACK[ \t]*=")
                                # 先尝试匹配带双引号的值
                                string(REGEX MATCH "DISTCC_FALLBACK[ \t]*=[ \t]*\"([^\"]+)\"" _ "${STRIPPED_LINE}")
                                if(CMAKE_MATCH_1)
                                    set(DISTCC_FALLBACK_VALUE "${CMAKE_MATCH_1}")
                                else()
                                    # 尝试匹配带单引号的值
                                    string(REGEX MATCH "DISTCC_FALLBACK[ \t]*=[ \t]*'([^']+)'" _ "${STRIPPED_LINE}")
                                    if(CMAKE_MATCH_1)
                                        set(DISTCC_FALLBACK_VALUE "${CMAKE_MATCH_1}")
                                    else()
                                        # 匹配不带引号的值
                                        string(REGEX REPLACE ".*DISTCC_FALLBACK[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_FALLBACK_VALUE "${STRIPPED_LINE}")
                                    endif()
                                endif()
                            endif()
                            # 提取 DISTCC_SKIP_LOCAL_RETRY（支持带引号和不带引号的值）
                            if(STRIPPED_LINE MATCHES "DISTCC_SKIP_LOCAL_RETRY[ \t]*=")
                                string(REGEX MATCH "DISTCC_SKIP_LOCAL_RETRY[ \t]*=[ \t]*\"([^\"]+)\"" _ "${STRIPPED_LINE}")
                                if(CMAKE_MATCH_1)
                                    set(DISTCC_SKIP_LOCAL_RETRY_VALUE "${CMAKE_MATCH_1}")
                                else()
                                    string(REGEX MATCH "DISTCC_SKIP_LOCAL_RETRY[ \t]*=[ \t]*'([^']+)'" _ "${STRIPPED_LINE}")
                                    if(CMAKE_MATCH_1)
                                        set(DISTCC_SKIP_LOCAL_RETRY_VALUE "${CMAKE_MATCH_1}")
                                    else()
                                        string(REGEX REPLACE ".*DISTCC_SKIP_LOCAL_RETRY[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_SKIP_LOCAL_RETRY_VALUE "${STRIPPED_LINE}")
                                    endif()
                                endif()
                            endif()
                            # 提取 DISTCC_IO_TIMEOUT（支持带引号和不带引号的值）
                            if(STRIPPED_LINE MATCHES "DISTCC_IO_TIMEOUT[ \t]*=")
                                string(REGEX MATCH "DISTCC_IO_TIMEOUT[ \t]*=[ \t]*\"([^\"]+)\"" _ "${STRIPPED_LINE}")
                                if(CMAKE_MATCH_1)
                                    set(DISTCC_IO_TIMEOUT_VALUE "${CMAKE_MATCH_1}")
                                else()
                                    string(REGEX MATCH "DISTCC_IO_TIMEOUT[ \t]*=[ \t]*'([^']+)'" _ "${STRIPPED_LINE}")
                                    if(CMAKE_MATCH_1)
                                        set(DISTCC_IO_TIMEOUT_VALUE "${CMAKE_MATCH_1}")
                                    else()
                                        string(REGEX REPLACE ".*DISTCC_IO_TIMEOUT[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_IO_TIMEOUT_VALUE "${STRIPPED_LINE}")
                                    endif()
                                endif()
                            endif()
                            # 提取 DISTCC_VERBOSE（支持带引号和不带引号的值）
                            if(STRIPPED_LINE MATCHES "DISTCC_VERBOSE[ \t]*=")
                                string(REGEX MATCH "DISTCC_VERBOSE[ \t]*=[ \t]*\"([^\"]+)\"" _ "${STRIPPED_LINE}")
                                if(CMAKE_MATCH_1)
                                    set(DISTCC_VERBOSE_VALUE "${CMAKE_MATCH_1}")
                                else()
                                    string(REGEX MATCH "DISTCC_VERBOSE[ \t]*=[ \t]*'([^']+)'" _ "${STRIPPED_LINE}")
                                    if(CMAKE_MATCH_1)
                                        set(DISTCC_VERBOSE_VALUE "${CMAKE_MATCH_1}")
                                    else()
                                        string(REGEX REPLACE ".*DISTCC_VERBOSE[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_VERBOSE_VALUE "${STRIPPED_LINE}")
                                    endif()
                                endif()
                            endif()
                            # 提取 DISTCC_SAVE_TEMPS（支持带引号和不带引号的值）
                            if(STRIPPED_LINE MATCHES "DISTCC_SAVE_TEMPS[ \t]*=")
                                string(REGEX MATCH "DISTCC_SAVE_TEMPS[ \t]*=[ \t]*\"([^\"]+)\"" _ "${STRIPPED_LINE}")
                                if(CMAKE_MATCH_1)
                                    set(DISTCC_SAVE_TEMPS_VALUE "${CMAKE_MATCH_1}")
                                else()
                                    string(REGEX MATCH "DISTCC_SAVE_TEMPS[ \t]*=[ \t]*'([^']+)'" _ "${STRIPPED_LINE}")
                                    if(CMAKE_MATCH_1)
                                        set(DISTCC_SAVE_TEMPS_VALUE "${CMAKE_MATCH_1}")
                                    else()
                                        string(REGEX REPLACE ".*DISTCC_SAVE_TEMPS[ \t]*=[ \t]*([^ \t\n#]+).*" "\\1" DISTCC_SAVE_TEMPS_VALUE "${STRIPPED_LINE}")
                                    endif()
                                endif()
                            endif()
                        endif()
                    endif()
                endforeach()
                
                # 设置默认值（如果配置文件中没有设置）
                # 🔥 关键：使用 STREQUAL "" 检查是否为空，而不是 NOT，因为 "0" 在 CMake 中被视为假值
                if(DISTCC_FALLBACK_VALUE STREQUAL "")
                    set(DISTCC_FALLBACK_VALUE "1")
                endif()
                if(DISTCC_SKIP_LOCAL_RETRY_VALUE STREQUAL "")
                    # 默认值：如果本机运行了 distccd，设置为 1（避免递归），否则使用配置文件或默认 0
                    # 注意：LOCAL_DISTCCD_RUNNING 此时还未检测，所以先设置为默认值 0
                    # 后续在检测到 LOCAL_DISTCCD_RUNNING 后，会覆盖此值
                    set(DISTCC_SKIP_LOCAL_RETRY_VALUE "0")
                endif()
                if(DISTCC_IO_TIMEOUT_VALUE STREQUAL "")
                    set(DISTCC_IO_TIMEOUT_VALUE "600")
                endif()
                if(DISTCC_VERBOSE_VALUE STREQUAL "")
                    set(DISTCC_VERBOSE_VALUE "0")
                endif()
                if(DISTCC_SAVE_TEMPS_VALUE STREQUAL "")
                    set(DISTCC_SAVE_TEMPS_VALUE "0")
                endif()
                
                if(DISTCC_HOSTS)
                    # 过滤本机 IP
                    execute_process(
                        COMMAND hostname -I
                        OUTPUT_VARIABLE HOSTNAME_IPS
                        OUTPUT_STRIP_TRAILING_WHITESPACE
                        ERROR_QUIET
                    )
                    
                    execute_process(
                        COMMAND ip addr show
                        COMMAND grep "inet "
                        COMMAND awk "{print $2}"
                        COMMAND cut -d/ -f1
                        COMMAND grep -v "127.0.0.1"
                        OUTPUT_VARIABLE IP_ADDR_IPS
                        OUTPUT_STRIP_TRAILING_WHITESPACE
                        ERROR_QUIET
                    )
                    
                    # 合并所有本机 IP
                    set(LOCAL_IPS "${HOSTNAME_IPS} ${IP_ADDR_IPS}")
                    string(STRIP "${LOCAL_IPS}" LOCAL_IPS)
                    
                    # 获取本地编译器版本（用于版本检查）
                    set(LOCAL_COMPILER_VERSION "")
                    set(LOCAL_COMPILER_NAME "GCC")
                    if(CMAKE_C_COMPILER)
                        get_filename_component(COMPILER_NAME "${CMAKE_C_COMPILER}" NAME)
                        if(COMPILER_NAME MATCHES "clang")
                            set(LOCAL_COMPILER_NAME "Clang")
                            # 获取 Clang 版本
                            execute_process(
                                COMMAND ${CMAKE_C_COMPILER} --version
                                OUTPUT_VARIABLE CLANG_VERSION_OUTPUT
                                OUTPUT_STRIP_TRAILING_WHITESPACE
                                ERROR_QUIET
                            )
                            # 提取主版本号（如 "clang version 14.0.0" -> "14"）
                            string(REGEX MATCH "clang version ([0-9]+)" _ "${CLANG_VERSION_OUTPUT}")
                            if(CMAKE_MATCH_1)
                                set(LOCAL_COMPILER_VERSION "${CMAKE_MATCH_1}")
                            endif()
                        else()
                            # 获取 GCC 版本
                            execute_process(
                                COMMAND ${CMAKE_C_COMPILER} -dumpversion
                                OUTPUT_VARIABLE GCC_VERSION_OUTPUT
                                OUTPUT_STRIP_TRAILING_WHITESPACE
                                ERROR_QUIET
                            )
                            # 提取主版本号（如 "9.4.0" -> "9"）
                            string(REGEX MATCH "^([0-9]+)" _ "${GCC_VERSION_OUTPUT}")
                            if(CMAKE_MATCH_1)
                                set(LOCAL_COMPILER_VERSION "${CMAKE_MATCH_1}")
                            endif()
                        endif()
                    endif()
                    
                    # 查找 nc (netcat) 程序（用于端口和版本检查）
                    find_program(NC_PROGRAM nc)
                    
                    # 验证主机连接和版本
                    set(VALID_HOSTS "")
                    set(INVALID_HOSTS "")
                    set(VERSION_MISMATCH_HOSTS "")
                    set(TOTAL_JOBS 0)
                    
                    # 获取本机 CPU 核心数
                    execute_process(
                        COMMAND nproc
                        OUTPUT_VARIABLE LOCAL_CPU_CORES
                        OUTPUT_STRIP_TRAILING_WHITESPACE
                        ERROR_QUIET
                    )
                    if(NOT LOCAL_CPU_CORES)
                        set(LOCAL_CPU_CORES "未知")
                    endif()
                    
                    # 用于存储 localhost 的 JOBS
                    set(LOCALHOST_JOBS "")
                    
                    # 🔥 关键：检测本机是否运行了 distccd 服务（防止递归调用）
                    set(LOCAL_DISTCCD_RUNNING FALSE)
                    execute_process(
                        COMMAND systemctl is-active distccd
                        OUTPUT_VARIABLE DISTCCD_STATUS
                        OUTPUT_STRIP_TRAILING_WHITESPACE
                        ERROR_QUIET
                    )
                    if(DISTCCD_STATUS STREQUAL "active")
                        set(LOCAL_DISTCCD_RUNNING TRUE)
                    else()
                        # 如果 systemctl 不可用，尝试使用 pgrep
                        execute_process(
                            COMMAND pgrep -x distccd
                            OUTPUT_QUIET
                            ERROR_QUIET
                            RESULT_VARIABLE PGREP_RESULT
                        )
                        if(PGREP_RESULT EQUAL 0)
                            set(LOCAL_DISTCCD_RUNNING TRUE)
                        endif()
                    endif()
                    
                    # 🔥 关键：如果检测到本地 distccd 运行，强制设置 DISTCC_SKIP_LOCAL_RETRY_VALUE=1
                    # 这确保即使配置文件中设置为 0，也会强制设置为 1 以避免递归
                    if(LOCAL_DISTCCD_RUNNING)
                        set(DISTCC_SKIP_LOCAL_RETRY_VALUE "1")
                        message(STATUS "⚠️  检测到本机正在运行 distccd 服务")
                        message(STATUS "   为避免递归调用，将从 DISTCC_HOSTS 中移除 localhost")
                        message(STATUS "   并强制设置 DISTCC_SKIP_LOCAL_RETRY=1")
                        message(STATUS "   提示: 如果不需要本地编译，可以停止 distccd 服务:")
                        message(STATUS "         sudo systemctl stop distccd")
                    endif()
                    
                    message(STATUS "检查远程主机连接状态...")
                    if(LOCAL_COMPILER_VERSION)
                        message(STATUS "本地编译器: ${LOCAL_COMPILER_NAME} ${LOCAL_COMPILER_VERSION}")
                    endif()
                    message(STATUS "本机 CPU 核心数: ${LOCAL_CPU_CORES}")
                    
                    # 分割主机列表
                    string(REPLACE " " ";" HOST_LIST "${DISTCC_HOSTS}")
                    
                    foreach(host_spec ${HOST_LIST})
                        if(host_spec)
                            # 提取 IP 地址
                            string(REGEX REPLACE "/.*" "" host_ip "${host_spec}")
                            string(REGEX REPLACE ",.*" "" host_ip "${host_ip}")
                            
                            # 检查是否为本机 IP
                            set(IS_LOCAL_IP FALSE)
                            if(LOCAL_IPS)
                                string(FIND "${LOCAL_IPS}" "${host_ip}" IP_FOUND)
                                if(NOT IP_FOUND EQUAL -1)
                                    set(IS_LOCAL_IP TRUE)
                                endif()
                            endif()
                            
                            # 跳过本机 IP（但保留 localhost，除非本机运行了 distccd）
                            if(IS_LOCAL_IP AND NOT host_ip STREQUAL "localhost")
                                continue()
                            endif()
                            
                            # 🔥 关键：如果本机运行了 distccd 服务，跳过 localhost（防止递归）
                            if(host_ip STREQUAL "localhost" AND LOCAL_DISTCCD_RUNNING)
                                message(STATUS "  ⚠️  跳过 localhost（本机运行了 distccd，避免递归调用）")
                                continue()
                            endif()
                            
                            # 🔥 临时解决方案：如果检测到递归调用问题，跳过 localhost
                            # 可以通过环境变量 DISTCC_SKIP_LOCALHOST=1 来强制跳过 localhost
                            if(host_ip STREQUAL "localhost" AND DEFINED ENV{DISTCC_SKIP_LOCALHOST} AND "$ENV{DISTCC_SKIP_LOCALHOST}" STREQUAL "1")
                                message(STATUS "  ⚠️  跳过 localhost（DISTCC_SKIP_LOCALHOST=1，避免递归调用）")
                                continue()
                            endif()
                            
                            # 第一步：检查端口连接
                            set(HOST_VALID FALSE)
                            set(PORT_CHECK_OK FALSE)
                            
                            if(host_ip STREQUAL "localhost")
                                # localhost 直接编译（不通过 distccd），安全
                                # 但如果有递归调用问题，建议移除 localhost
                                set(HOST_VALID TRUE)
                                set(PORT_CHECK_OK TRUE)
                                # 提取 localhost 的 JOBS
                                string(REGEX MATCH "/([0-9]+)" _ "${host_spec}")
                                if(CMAKE_MATCH_1)
                                    set(LOCALHOST_JOBS "${CMAKE_MATCH_1}")
                                else()
                                    set(LOCALHOST_JOBS "4")  # 默认 4 个槽位
                                endif()
                            else()
                                # 方法 1: 使用 nc (netcat) 检查端口 3632
                                if(NC_PROGRAM)
                                    execute_process(
                                        COMMAND ${NC_PROGRAM} -z -w 2 ${host_ip} 3632
                                        OUTPUT_QUIET
                                        ERROR_QUIET
                                        RESULT_VARIABLE NC_RESULT
                                        TIMEOUT 3
                                    )
                                    if(NC_RESULT EQUAL 0)
                                        set(HOST_VALID TRUE)
                                        set(PORT_CHECK_OK TRUE)
                                    endif()
                                endif()
                                
                                # 方法 2: 使用 bash /dev/tcp（如果 nc 不可用或失败）
                                if(NOT PORT_CHECK_OK)
                                    execute_process(
                                        COMMAND bash -c "timeout 2 bash -c '</dev/tcp/${host_ip}/3632' 2>/dev/null && echo 'ok' || echo 'fail'"
                                        OUTPUT_VARIABLE PORT_CHECK_RESULT
                                        OUTPUT_STRIP_TRAILING_WHITESPACE
                                        ERROR_QUIET
                                        TIMEOUT 3
                                    )
                                    if(PORT_CHECK_RESULT STREQUAL "ok")
                                        set(HOST_VALID TRUE)
                                        set(PORT_CHECK_OK TRUE)
                                    endif()
                                endif()
                                
                                # 方法 3: 使用 ping（备用方法，仅网络连通性检查）
                                if(NOT PORT_CHECK_OK)
                                    execute_process(
                                        COMMAND ping -c 1 -W 2 ${host_ip}
                                        OUTPUT_QUIET
                                        ERROR_QUIET
                                        RESULT_VARIABLE PING_RESULT
                                        TIMEOUT 3
                                    )
                                    if(PING_RESULT EQUAL 0)
                                        # ping 通但端口不通，标记为无效
                                        set(HOST_VALID FALSE)
                                    endif()
                                endif()
                            endif()
                            
                            # 第二步：如果端口检查通过，检查编译器版本（如果启用）
                            set(VERSION_CHECK_OK TRUE)
                            set(VERSION_MISMATCH_INFO "")
                            if(HOST_VALID AND PORT_CHECK_OK AND DISTCC_CHECK_GCC_VERSION STREQUAL "yes" AND LOCAL_COMPILER_VERSION)
                                # 通过 3633 端口获取远程主机信息
                                if(NC_PROGRAM)
                                    execute_process(
                                        COMMAND ${NC_PROGRAM} -w 1 ${host_ip} 3633
                                        OUTPUT_VARIABLE REMOTE_INFO
                                        OUTPUT_STRIP_TRAILING_WHITESPACE
                                        ERROR_QUIET
                                        TIMEOUT 2
                                    )
                                    
                                    if(REMOTE_INFO)
                                        # 解析远程编译器版本
                                        set(REMOTE_COMPILER_VERSION "")
                                        set(REMOTE_COMPILER_NAME "")
                                        
                                        # 🔥 关键改进：检查远程服务器是否支持客户端使用的编译器类型
                                        # 远程服务器可能同时安装了 Clang 和 GCC，需要检查对应的版本
                                        
                                        if(LOCAL_COMPILER_NAME STREQUAL "Clang")
                                            # 客户端使用 Clang，检查远程服务器的 Clang 版本
                                            string(REGEX MATCH "PRIMARY_COMPILER=([^\n]+)" _ "${REMOTE_INFO}")
                                            if(CMAKE_MATCH_1)
                                                string(STRIP "${CMAKE_MATCH_1}" REMOTE_PRIMARY_COMPILER)
                                                if(REMOTE_PRIMARY_COMPILER STREQUAL "clang")
                                                    # 远程主要编译器是 Clang，使用 PRIMARY_COMPILER_MAJOR
                                                    string(REGEX MATCH "PRIMARY_COMPILER_MAJOR=([0-9]+)" _ "${REMOTE_INFO}")
                                                    if(CMAKE_MATCH_1)
                                                        set(REMOTE_COMPILER_VERSION "${CMAKE_MATCH_1}")
                                                        set(REMOTE_COMPILER_NAME "Clang")
                                                    endif()
                                                else()
                                                    # 远程主要编译器是 GCC，但可能也安装了 Clang
                                                    # 检查远程服务器是否支持 Clang（通过检查是否有 clang 命令）
                                                    # 注意：版本服务不报告备选编译器，所以这里假设如果主要编译器是 GCC，
                                                    # 但客户端使用 Clang，则可能不匹配
                                                    # 实际上，如果远程服务器安装了 Clang，distccd 应该能找到它（通过 PATH）
                                                    # 所以这里只做警告，不阻止连接
                                                    set(VERSION_CHECK_OK TRUE)  # 允许连接，让 distccd 尝试
                                                    set(VERSION_MISMATCH_INFO "远程主要编译器是 GCC，但可能也支持 Clang（将通过 distccd 自动检测）")
                                                endif()
                                            endif()
                                        else()
                                            # 客户端使用 GCC，检查远程服务器的 GCC 版本
                                            # 远程服务器可能主要使用 Clang，但也安装了 GCC
                                            string(REGEX MATCH "GCC_MAJOR=([0-9]+)" _ "${REMOTE_INFO}")
                                            if(CMAKE_MATCH_1)
                                                set(REMOTE_COMPILER_VERSION "${CMAKE_MATCH_1}")
                                                set(REMOTE_COMPILER_NAME "GCC")
                                            else()
                                                # 无法获取 GCC 版本，可能远程服务器只安装了 Clang
                                                # 检查远程主要编译器
                                                string(REGEX MATCH "PRIMARY_COMPILER=([^\n]+)" _ "${REMOTE_INFO}")
                                                if(CMAKE_MATCH_1)
                                                    string(STRIP "${CMAKE_MATCH_1}" REMOTE_PRIMARY_COMPILER)
                                                    if(REMOTE_PRIMARY_COMPILER STREQUAL "clang")
                                                        # 远程主要编译器是 Clang，但可能也安装了 GCC
                                                        # 允许连接，让 distccd 尝试（如果远程安装了 GCC，distccd 能找到它）
                                                        set(VERSION_CHECK_OK TRUE)
                                                        set(VERSION_MISMATCH_INFO "远程主要编译器是 Clang，但可能也支持 GCC（将通过 distccd 自动检测）")
                                                    else()
                                                        # 远程主要编译器是 GCC，但无法获取版本
                                                        set(VERSION_MISMATCH_INFO "无法获取远程 GCC 版本（版本服务可能未正确配置）")
                                                    endif()
                                                endif()
                                            endif()
                                        endif()
                                        
                                        # 比较版本（只有在找到匹配的编译器类型时才比较）
                                        if(REMOTE_COMPILER_VERSION AND REMOTE_COMPILER_NAME STREQUAL LOCAL_COMPILER_NAME)
                                            if(NOT REMOTE_COMPILER_VERSION STREQUAL LOCAL_COMPILER_VERSION)
                                                set(VERSION_CHECK_OK FALSE)
                                                set(VERSION_MISMATCH_INFO "版本不匹配: 本地=${LOCAL_COMPILER_NAME}-${LOCAL_COMPILER_VERSION}, 远程=${REMOTE_COMPILER_NAME}-${REMOTE_COMPILER_VERSION}")
                                            endif()
                                        elseif(NOT REMOTE_COMPILER_VERSION AND NOT VERSION_MISMATCH_INFO)
                                            # 无法获取远程版本，警告但不阻止
                                            set(VERSION_MISMATCH_INFO "无法获取远程编译器版本（版本服务可能未启动）")
                                        endif()
                                    else()
                                        # 无法连接版本服务端口
                                        set(VERSION_MISMATCH_INFO "无法连接版本服务端口 3633")
                                    endif()
                                endif()
                            endif()
                            
                            # 最终判断：端口通过且版本检查通过（如果启用）
                            if(HOST_VALID AND PORT_CHECK_OK AND VERSION_CHECK_OK)
                                # 提取槽位数
                                string(REGEX MATCH "/([0-9]+)" _ "${host_spec}")
                                if(CMAKE_MATCH_1)
                                    set(host_jobs "${CMAKE_MATCH_1}")
                                else()
                                    set(host_jobs "4")  # 默认 4 个槽位
                                endif()
                                
                                # 如果是 localhost，检查并限制 JOBS 不超过 CPU*2
                                set(host_jobs_adjusted FALSE)
                                if(host_ip STREQUAL "localhost" AND NOT LOCAL_CPU_CORES STREQUAL "未知")
                                    math(EXPR CPU_CORES_INT "${LOCAL_CPU_CORES}")
                                    math(EXPR JOBS_INT "${host_jobs}")
                                    math(EXPR MAX_JOBS "${CPU_CORES_INT} * 2")
                                    
                                    # 如果超过 CPU*2，自动调整为 CPU*2
                                    if(JOBS_INT GREATER MAX_JOBS)
                                        set(host_jobs "${MAX_JOBS}")
                                        set(host_jobs_adjusted TRUE)
                                        # 更新 host_spec 以反映调整后的 JOBS
                                        string(REGEX REPLACE "/([0-9]+)" "/${MAX_JOBS}" host_spec "${host_spec}")
                                        # 更新 LOCALHOST_JOBS 变量
                                        set(LOCALHOST_JOBS "${MAX_JOBS}")
                                    endif()
                                endif()
                                
                                # 计算槽位（包括 localhost，但排除其他本机 IP）
                                # localhost 需要计入 TOTAL_JOBS，因为它是本地编译槽位
                                if(host_ip STREQUAL "localhost" OR NOT IS_LOCAL_IP)
                                    math(EXPR TOTAL_JOBS "${TOTAL_JOBS} + ${host_jobs}")
                                endif()
                                
                                if(VALID_HOSTS)
                                    set(VALID_HOSTS "${VALID_HOSTS} ${host_spec}")
                                else()
                                    set(VALID_HOSTS "${host_spec}")
                                endif()
                                
                                if(VERSION_MISMATCH_INFO)
                                    message(STATUS "  ✅ ${host_spec} (⚠️  ${VERSION_MISMATCH_INFO})")
                                else()
                                    # 如果是 localhost，显示 CPU 核心数和 JOBS 对比
                                    if(host_ip STREQUAL "localhost" AND LOCALHOST_JOBS)
                                        if(LOCAL_CPU_CORES STREQUAL "未知")
                                            message(STATUS "  ✅ ${host_spec} | 本机 CPU: ${LOCAL_CPU_CORES}, localhost JOBS: ${LOCALHOST_JOBS}")
                                        else()
                                            math(EXPR CPU_CORES_INT "${LOCAL_CPU_CORES}")
                                            math(EXPR JOBS_INT "${LOCALHOST_JOBS}")
                                            math(EXPR MAX_JOBS "${CPU_CORES_INT} * 2")
                                            
                                            # 如果已调整，显示调整信息
                                            if(host_jobs_adjusted)
                                                message(STATUS "  ⚠️  ${host_spec} | 本机 CPU: ${LOCAL_CPU_CORES}, localhost JOBS: ${LOCALHOST_JOBS} (已自动调整为 CPU*2=${MAX_JOBS})")
                                                message(STATUS "     💡 提示: localhost JOBS 已自动限制为 CPU 核心数*2，避免过度并行")
                                            elseif(JOBS_INT EQUAL CPU_CORES_INT)
                                                message(STATUS "  ✅ ${host_spec} | 本机 CPU: ${LOCAL_CPU_CORES}, localhost JOBS: ${LOCALHOST_JOBS} (匹配)")
                                            elseif(JOBS_INT GREATER CPU_CORES_INT)
                                                math(EXPR JOBS_DIFF "${JOBS_INT} - ${CPU_CORES_INT}")
                                                message(STATUS "  ✅ ${host_spec} | 本机 CPU: ${LOCAL_CPU_CORES}, localhost JOBS: ${LOCALHOST_JOBS} (+${JOBS_DIFF})")
                                            else()
                                                math(EXPR JOBS_DIFF "${CPU_CORES_INT} - ${JOBS_INT}")
                                                message(STATUS "  ✅ ${host_spec} | 本机 CPU: ${LOCAL_CPU_CORES}, localhost JOBS: ${LOCALHOST_JOBS} (-${JOBS_DIFF})")
                                            endif()
                                        endif()
                                    else()
                                        message(STATUS "  ✅ ${host_spec}")
                                    endif()
                                endif()
                            else()
                                if(NOT PORT_CHECK_OK)
                                    if(INVALID_HOSTS)
                                        set(INVALID_HOSTS "${INVALID_HOSTS} ${host_spec}")
                                    else()
                                        set(INVALID_HOSTS "${host_spec}")
                                    endif()
                                    message(STATUS "  ❌ ${host_spec} (端口 3632 不可访问)")
                                elseif(NOT VERSION_CHECK_OK)
                                    if(VERSION_MISMATCH_HOSTS)
                                        set(VERSION_MISMATCH_HOSTS "${VERSION_MISMATCH_HOSTS} ${host_spec}")
                                    else()
                                        set(VERSION_MISMATCH_HOSTS "${host_spec}")
                                    endif()
                                    # 解析版本信息，提取本地和远程版本
                                    string(REGEX MATCH "本地=([^,]+)" _ "${VERSION_MISMATCH_INFO}")
                                    set(LOCAL_VER "${CMAKE_MATCH_1}")
                                    string(REGEX MATCH "远程=([^)]+)" _ "${VERSION_MISMATCH_INFO}")
                                    set(REMOTE_VER "${CMAKE_MATCH_1}")
                                    if(LOCAL_VER AND REMOTE_VER)
                                        message(STATUS "  ⚠️  ${host_spec} (版本不匹配: 本地=${LOCAL_VER}, 远程=${REMOTE_VER})")
                                    else()
                                        message(STATUS "  ⚠️  ${host_spec} (${VERSION_MISMATCH_INFO})")
                                    endif()
                                endif()
                            endif()
                        endif()
                    endforeach()
                    
                    # 显示检查结果摘要
                    if(INVALID_HOSTS)
                        message(STATUS "")
                        message(STATUS "端口检查失败的主机:")
                        string(REPLACE " " "\n  " INVALID_LIST "${INVALID_HOSTS}")
                        message(STATUS "  ${INVALID_LIST}")
                    endif()
                    if(VERSION_MISMATCH_HOSTS)
                        message(STATUS "")
                        message(STATUS "⚠️  以下远程编译主机编译器版本不匹配（已排除）:")
                        string(REPLACE " " "\n  " MISMATCH_LIST "${VERSION_MISMATCH_HOSTS}")
                        message(STATUS "  ${MISMATCH_LIST}")
                        message(STATUS "")
                        message(STATUS "💡 解决方案:")
                        message(STATUS "  方案 1: 统一编译器版本（强烈推荐）")
                        message(STATUS "    在远程编译机上安装与本地相同版本的 GCC:")
                        message(STATUS "    Ubuntu/Debian: sudo apt install -y gcc-${LOCAL_COMPILER_VERSION} g++-${LOCAL_COMPILER_VERSION}")
                        message(STATUS "    CentOS/RHEL: sudo yum install -y devtoolset-${LOCAL_COMPILER_VERSION}-gcc devtoolset-${LOCAL_COMPILER_VERSION}-gcc-c++")
                        message(STATUS "")
                        message(STATUS "  方案 2: 关闭版本检查（不推荐，可能导致编译失败）")
                        message(STATUS "    编辑 ci/distcc.conf，设置: DISTCC_CHECK_GCC_VERSION=no")
                        message(STATUS "")
                        message(STATUS "  详细说明请参考: docs/构建性能优化完整指南.md")
                    endif()
                    
                    if(VALID_HOSTS)
                        # 设置 distcc 环境变量
                        set(ENV{DISTCC_HOSTS} "${VALID_HOSTS}")
                        # 🔥 关键：使用配置文件中的值，而不是硬编码
                        set(ENV{DISTCC_FALLBACK} "${DISTCC_FALLBACK_VALUE}")
                        # 🔥 关键：设置 DISTCC_SKIP_LOCAL_RETRY
                        # 如果本机运行了 distccd，强制设置为 1（避免递归）
                        # 否则使用配置文件中的值
                        if(LOCAL_DISTCCD_RUNNING)
                            set(ENV{DISTCC_SKIP_LOCAL_RETRY} "1")
                        else()
                            set(ENV{DISTCC_SKIP_LOCAL_RETRY} "${DISTCC_SKIP_LOCAL_RETRY_VALUE}")
                        endif()
                        set(ENV{DISTCC_IO_TIMEOUT} "${DISTCC_IO_TIMEOUT_VALUE}")
                        set(ENV{DISTCC_VERBOSE} "${DISTCC_VERBOSE_VALUE}")
                        set(ENV{DISTCC_SAVE_TEMPS} "${DISTCC_SAVE_TEMPS_VALUE}")
                        
                        # 🔥 关键配置：让 ccache 使用 distcc
                        set(ENV{CCACHE_PREFIX} "distcc")
                        
                        # 🔥 关键：防止 distcc 递归调用 ccache 包装器
                        # 设置 CCACHE_PATH，确保 distcc 调用真实编译器
                        set(ENV{CCACHE_PATH} "/usr/bin:/usr/local/bin")
                        
                        # 🔥 关键：设置 DISTCC_PATH，确保 distcc 和 distccd 调用真实编译器
                        # 这会影响 distcc 客户端（查找编译器）和 distccd 服务器端（执行编译器）
                        set(ENV{DISTCC_PATH} "/usr/bin:/usr/local/bin")
                        
                        # 🔥 关键：设置 PATH，确保 distcc 和 distccd 调用真实编译器
                        # 移除所有 ccache 目录，避免递归调用
                        # 标准路径必须在最前面
                        set(ENV{PATH} "/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/bin:/sbin")
                        
                        # 🔥 关键：创建或更新 ccache-distcc launcher 脚本
                        # 确保 DISTCC_HOSTS 被硬编码到脚本中（CLion 等 IDE 需要）
                        # 查找 ccache 程序
                        find_program(CCACHE_PROGRAM ccache)
                        if(CCACHE_PROGRAM)
                            # 获取 ccache 缓存目录（从 CompileCache 模块设置的变量或环境变量）
                            if(DEFINED CCACHE_DIR)
                                # 使用 CompileCache 模块设置的变量
                                set(LAUNCHER_CCACHE_DIR "${CCACHE_DIR}")
                            elseif(DEFINED ENV{CCACHE_DIR})
                                # 使用环境变量
                                set(LAUNCHER_CCACHE_DIR "$ENV{CCACHE_DIR}")
                            else()
                                # 默认值
                                set(LAUNCHER_CCACHE_DIR "${CMAKE_BINARY_DIR}/.ccache")
                            endif()
                            
                            # 获取 ccache 配置文件路径
                            if(DEFINED CCACHE_CONFIG_FILE)
                                set(LAUNCHER_CCACHE_CONFIG "${CCACHE_CONFIG_FILE}")
                            else()
                                set(LAUNCHER_CCACHE_CONFIG "${CMAKE_BINARY_DIR}/ccache.conf")
                            endif()
                            
                            # 创建组合 launcher 脚本
                            set(CCACHE_DISTCC_LAUNCHER "${CMAKE_BINARY_DIR}/ccache_distcc_launcher.sh")
                            file(WRITE "${CCACHE_DISTCC_LAUNCHER}" "#!/bin/bash
# ccache-distcc 组合 launcher
# 🔥 关键：强制设置 CCACHE_DIR，确保使用构建目录下的缓存
export CCACHE_DIR=\"${LAUNCHER_CCACHE_DIR}\"
export CCACHE_CONFIGPATH=\"${LAUNCHER_CCACHE_CONFIG}\"
# 🔥 关键：设置 CCACHE_PATH，确保 distcc 调用真实编译器，不是 ccache 包装器
# 排除所有 ccache 目录，避免递归调用
export CCACHE_PATH=\"/usr/bin:/usr/local/bin\"
export CCACHE_PREFIX=\"distcc\"
# 🔥 关键：硬编码 DISTCC_HOSTS，不依赖运行时环境变量（CLion 等 IDE 需要）
export DISTCC_HOSTS=\"${VALID_HOSTS}\"
# 🔥 关键：设置 DISTCC_PATH，确保 distccd 调用真实编译器，不是 ccache 包装器
# 这会影响 distcc 客户端和 distccd 服务器端
export DISTCC_PATH=\"/usr/bin:/usr/local/bin\"
# 🔥 关键：设置 PATH，确保 distcc 和 distccd 调用真实编译器
# 移除所有 ccache 目录，避免递归调用
# 标准路径必须在最前面
export PATH=\"/usr/bin:/usr/local/bin:/usr/local/sbin:/usr/sbin:/bin:/sbin\"
# 🔥 关键：使用配置文件中的值，而不是硬编码
export DISTCC_FALLBACK=\"${DISTCC_FALLBACK_VALUE}\"
# 🔥 关键：设置 DISTCC_SKIP_LOCAL_RETRY
# 如果本机运行了 distccd，强制设置为 1（避免递归）
# 否则使用配置文件中的值
# 注意：LOCAL_DISTCCD_RUNNING 在 launcher 创建时已经检测并设置到 DISTCC_SKIP_LOCAL_RETRY_VALUE 中
export DISTCC_SKIP_LOCAL_RETRY=\"${DISTCC_SKIP_LOCAL_RETRY_VALUE}\"
export DISTCC_IO_TIMEOUT=\"${DISTCC_IO_TIMEOUT_VALUE}\"
export DISTCC_VERBOSE=\"${DISTCC_VERBOSE_VALUE}\"
export DISTCC_SAVE_TEMPS=\"${DISTCC_SAVE_TEMPS_VALUE}\"
# 🔥 关键：清除 shell 的路径缓存，确保使用新的 PATH
hash -r 2>/dev/null || true
# 🔥 关键：验证编译器路径（调试用，可以注释掉）
# if [ \"\$DISTCC_VERBOSE\" = \"1\" ]; then
#     echo \"[DEBUG] PATH: \$PATH\" >&2
#     echo \"[DEBUG] DISTCC_PATH: \$DISTCC_PATH\" >&2
#     echo \"[DEBUG] which gcc: \$(which gcc 2>&1)\" >&2
#     echo \"[DEBUG] which clang: \$(which clang 2>&1)\" >&2
# fi
# 每次调用都设置缓存目录（覆盖配置文件中的设置）
# 使用 --set-config 确保配置生效
${CCACHE_PROGRAM} --set-config cache_dir=\"${LAUNCHER_CCACHE_DIR}\" >/dev/null 2>&1 || true
# 执行 ccache（会使用上面设置的 CCACHE_DIR 环境变量）
exec ${CCACHE_PROGRAM} \"\$@\"
")
                            # 设置文件执行权限
                            execute_process(
                                COMMAND chmod +x "${CCACHE_DISTCC_LAUNCHER}"
                                OUTPUT_QUIET
                                ERROR_QUIET
                            )
                            
                            # 设置编译器 launcher（覆盖 CompileCache 中的设置）
                            set(CMAKE_C_COMPILER_LAUNCHER "${CCACHE_DISTCC_LAUNCHER}" CACHE STRING "C compiler launcher" FORCE)
                            set(CMAKE_CXX_COMPILER_LAUNCHER "${CCACHE_DISTCC_LAUNCHER}" CACHE STRING "CXX compiler launcher" FORCE)
                            
                            message(STATUS "")
                            message(STATUS "✅ distcc launcher 已更新（CLion 等 IDE 可用）")
                            message(STATUS "   Launcher: ${CCACHE_DISTCC_LAUNCHER}")
                            message(STATUS "   distcc 主机: ${VALID_HOSTS}")
                            message(STATUS "   缓存目录: ${LAUNCHER_CCACHE_DIR}")
                        endif()
                        
                        # 计算并设置 JOBS
                        if(TOTAL_JOBS GREATER 0)
                            if(DISTCC_DYNAMIC_BALANCE STREQUAL "yes")
                                # 动态均衡模式：使用 100% 槽位
                                set(ENV{DISTCC_JOBS} "${TOTAL_JOBS}")
                                set(CMAKE_BUILD_PARALLEL_LEVEL "${TOTAL_JOBS}" CACHE STRING "并行编译任务数" FORCE)
                                message(STATUS "")
                                message(STATUS "🚀 动态均衡模式：JOBS = ${TOTAL_JOBS}")
                                message(STATUS "   📝 make -j${TOTAL_JOBS} 使用远程编译槽位总数 (100%)")
                                message(STATUS "   📝 动态均衡将根据 CPU 负载自动调整")
                            else()
                                # 静态模式：使用 100% 槽位（保守策略可以在这里调整）
                                set(ENV{DISTCC_JOBS} "${TOTAL_JOBS}")
                                set(CMAKE_BUILD_PARALLEL_LEVEL "${TOTAL_JOBS}" CACHE STRING "并行编译任务数" FORCE)
                                message(STATUS "")
                                message(STATUS "🚀 静态模式：JOBS = ${TOTAL_JOBS}")
                                message(STATUS "   📝 make -j${TOTAL_JOBS} 使用远程编译槽位总数")
                                message(STATUS "   💡 提示：可启用 DISTCC_DYNAMIC_BALANCE=yes 实现自动调整")
                            endif()
                        else()
                            # 没有远程主机，使用本地核心数
                            execute_process(
                                COMMAND nproc
                                OUTPUT_VARIABLE LOCAL_CORES
                                OUTPUT_STRIP_TRAILING_WHITESPACE
                                ERROR_QUIET
                            )
                            if(NOT LOCAL_CORES)
                                set(LOCAL_CORES "4")
                            endif()
                            set(CMAKE_BUILD_PARALLEL_LEVEL "${LOCAL_CORES}" CACHE STRING "并行编译任务数" FORCE)
                            message(STATUS "")
                            message(STATUS "⚠️  没有可用的远程主机，使用本地编译")
                            message(STATUS "   JOBS = ${LOCAL_CORES} (本地核心数)")
                        endif()
                        
                        message(STATUS "")
                        message(STATUS "可用主机: ${VALID_HOSTS}")
                        message(STATUS "并行任务: ${TOTAL_JOBS}")
                        message(STATUS "")
                        message(STATUS "💡 提示: ccache + distcc 组合使用")
                        message(STATUS "   - ccache 提供缓存加速")
                        message(STATUS "   - distcc 提供分布式编译")
                        message(STATUS "========================================")
                    else()
                        message(STATUS "")
                        message(STATUS "⚠️  所有远程编译主机都不可用，将仅使用本地编译")
                        message(STATUS "请检查：")
                        message(STATUS "  1. 远程机器是否运行了 distccd 服务")
                        message(STATUS "  2. 防火墙是否开放了 3632 端口")
                        message(STATUS "  3. 网络连接是否正常")
                        message(STATUS "========================================")
                    endif()
                endif()
            endif()
        endif()
    endif()
endif()

